/**
 * API配置文件
 * 统一管理API基础配置和请求拦截器
 */
import axios from 'axios';

// API基础配置
export const API_BASE_URL = 'http://localhost:8000';
export const API_PREFIX = '/api';

// 创建axios实例
const apiClient = axios.create({
  baseURL: API_BASE_URL,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// 请求拦截器
apiClient.interceptors.request.use(
  (config) => {
    // 添加认证token
    const token = localStorage.getItem('token');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

// 响应拦截器
apiClient.interceptors.response.use(
  (response) => {
    // 统一处理响应数据
    return response;
  },
  (error) => {
    // 统一错误处理
    if (error.response) {
      const { status, data } = error.response;
      
      switch (status) {
        case 401:
          // 未授权，清除token并跳转登录
          localStorage.removeItem('token');
          localStorage.removeItem('user');
          window.location.href = '/login';
          break;
        case 403:
          console.error('权限不足');
          break;
        case 404:
          console.error('资源不存在');
          break;
        case 409:
          console.error(data.message || '资源冲突');
          break;
        case 422:
          console.error('请求参数验证失败');
          break;
        default:
          console.error(data.message || '请求失败');
      }
    } else {
      console.error('网络错误，请检查网络连接');
    }
    return Promise.reject(error);
  }
);

export default apiClient;

/**
 * Token管理工具类
 */
export class TokenManager {
  /**
   * 设置token
   * @param {string} token - JWT token
   */
  static setToken(token) {
    localStorage.setItem('token', token);
  }
  
  /**
   * 获取token
   * @returns {string|null} token
   */
  static getToken() {
    return localStorage.getItem('token');
  }
  
  /**
   * 移除token
   */
  static removeToken() {
    localStorage.removeItem('token');
    localStorage.removeItem('user');
  }
  
  /**
   * 检查token是否有效
   * @returns {boolean} token是否有效
   */
  static isTokenValid() {
    const token = this.getToken();
    if (!token) return false;
    
    try {
      const payload = JSON.parse(atob(token.split('.')[1]));
      return payload.exp * 1000 > Date.now();
    } catch {
      return false;
    }
  }
}

/**
 * API缓存管理
 */
export class ApiCache {
  constructor(ttl = 5 * 60 * 1000) { // 默认5分钟
    this.cache = new Map();
    this.ttl = ttl;
  }
  
  /**
   * 设置缓存
   * @param {string} key - 缓存键
   * @param {any} data - 缓存数据
   */
  set(key, data) {
    this.cache.set(key, {
      data,
      timestamp: Date.now()
    });
  }
  
  /**
   * 获取缓存
   * @param {string} key - 缓存键
   * @returns {any|null} 缓存数据
   */
  get(key) {
    const item = this.cache.get(key);
    if (!item) return null;
    
    if (Date.now() - item.timestamp > this.ttl) {
      this.cache.delete(key);
      return null;
    }
    
    return item.data;
  }
  
  /**
   * 清除所有缓存
   */
  clear() {
    this.cache.clear();
  }
}

// 创建全局缓存实例
export const apiCache = new ApiCache();

/**
 * 带缓存的API调用
 * @param {string} key - 缓存键
 * @param {Function} apiCall - API调用函数
 * @returns {Promise<any>} API响应数据
 */
export const getCachedData = async (key, apiCall) => {
  const cached = apiCache.get(key);
  if (cached) return cached;
  
  const data = await apiCall();
  apiCache.set(key, data);
  return data;
};

/**
 * 请求重试机制
 * @param {Function} apiCall - API调用函数
 * @param {number} maxRetries - 最大重试次数
 * @returns {Promise<any>} API响应数据
 */
export const apiWithRetry = async (apiCall, maxRetries = 3) => {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await apiCall();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      
      // 指数退避
      await new Promise(resolve => 
        setTimeout(resolve, Math.pow(2, i) * 1000)
      );
    }
  }
};